package ArrayStudy;

import java.util.Scanner;

/**
 * 12, 14, 10, 5, 6, 7
 * <p>
 * 10, 5, 6, 7, 12, 14
 * <p>
 * 冒泡排序（思想）
 * 1.    0 1 2
 * 2.
 * <p>
 * 选择思想 5
 * 1.   5,  14, 10, 12, 6, 7
 * 2.   5,  6, 10, 12, 14, 7
 * n-1   ……
 * 抽象  n n-1
 * 1.找极值  找最小值的下标
 * 2.查找范围内第一个数
 * 封装 重用性  解耦 高内聚 低耦合
 * <p>
 * <p>
 * 冒泡排序
 * <p>
 * 原始数组：2 1 5 4 6 7 8
 * 4 6 7 8 2 15
 * 1.保护前三个
 * 2. 从第四个移动位置到第一个
 * 3. 把后三个接上
 * <p>
 * 3
 * 4 6 7 8 2 1 5
 * 2
 * 5 4 6 7 8 2 1
 * 1
 * 1 5 4 6 7 8 2
 * 思路:
 */
public class ArraySort {
    public static void main(String[] args) {
        int[] arr = {12, 14, 10, 5, 6, 7, 8};//局部变量
        ArraySort.outPut(arr,arr.length);
        int[] arr1 = new int[arr.length];
        System.out.println("请输入要移动位置的下标");
        Scanner scanner = new Scanner(System.in);
        int index = scanner.nextInt();//3  0  1 2
        int index1=0;
        //1.保护前index个数据
        for (int i = 0; i < index; i++) {
            arr1[i] = arr[i];
        }
        //2.从下标第index开始移动位置
        for(int j=index;j<arr.length;j++)
        {
            arr[index1++]=arr[j];
        }
        //3.把保护的数据接上去
        for (int i = 0; i < index; i++) {
            arr[index1++] = arr1[i];
        }

       ArraySort.outPut(arr,arr.length);





//        int[] arr = new int[100];
//        int len = 5, r;
//        ArraySort.inPut(arr, len);//输入
//        System.out.println("请输入你要查找的数据:");
//        Scanner scanner = new Scanner(System.in);
//        int data = scanner.nextInt();

//        if (ArraySort.delData(arr, len, data))
//        {
//            System.out.println("删除成功");
//            ArraySort.outPut(arr,len-1);
//        }else{
//            System.out.println("删除失败。");
//            ArraySort.outPut(arr,len);
//        }

//        String info = ArraySort.findData(arr, len, data) ? "找到啦" : "没找到";
//        System.out.println("info = " + info);
//        if (ArraySort.findData(arr, len, data)) {
//            if (ArraySort.delData(arr, len, data)) {
//                System.out.println("删除成功");
//                ArraySort.outPut(arr, len);
//            } else {
//                System.out.println("删除失败");
//            }
//        }

//        System.out.println("排序前");
//        ArraySort.outPut(arr, len);
        //类名.方法名
//        ArraySort.sortArray(arr, len);
//        ArraySort.sortArr(arr, len);//排序
//        System.out.println("排序后");
//        ArraySort.outPut(arr, len);//输出
    }

    /**
     * 冒泡排序
     *
     * @param arr
     * @param len
     */
    public static void sortArray(int[] arr, int len) {
        int r;
        for (int i = 0; i < len - 1; i++) {//len=6
            for (int j = 0; j < len - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    r = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = r;
                }
            }
        }
    }


    /**
     * @param arr
     * @param len
     */
    public static void inPut(int[] arr, int len) {
        System.out.println("请给数组输入连续的" + len + "个数据");
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < len; i++) {
            arr[i] = scanner.nextInt();
        }
    }

    /**
     * 封装输出
     */
    public static void outPut(int[] arr, int len)//形参
    {
        for (int i = 0; i < len; i++) {
            System.out.print(" " + arr[i]);
        }
        System.out.println();
    }

    /**
     * 选择排序实现
     *
     * @param arr Int数组
     */
    public static void sortArr(int[] arr, int len) {
        int x, r;
        for (int i = 0; i < len - 1; i++) {
            x = i;//x=0 中间值
            //找最小值下标
            for (int j = i + 1; j < len; j++) {
                if (arr[j] < arr[x])//arr[1]<arr[0]
                {
                    x = j;
                }
            }
            //最小值和查找范围内的第一个数交换
            if (x != i) {
                r = arr[x];
                arr[x] = arr[i];
                arr[i] = r;
            }
        }
    }

    /**
     * 需求：要求用户输入一个要查找的数字，从数组中进行查找
     * 如果找到，则输出结果，否则：提醒用户，数据并不存在
     */
    public static boolean findData(int[] arr, int len, int data) {
        for (int i = 0; i < len; i++) {
            if (arr[i] == data) {
                return true;
            }
        }
        return false;
    }

    /**
     * @param arr  原数组
     * @param len  有效长度
     * @param data 删除数据
     * @return
     */
    public static boolean delData(int[] arr, int len, int data) {
        int x = 0, i;
        for (i = 0; i < len; i++) {
            if (arr[i] == data) {
                x = i;//3
                break;
            }
        }
        if (i == len) {
            return false;
        } else {
            //找到啦，开始移位删除
            for (int j = x; j < len - 1; j++)//3 4 5
            {

                arr[j] = arr[j + 1];
            }
            return true;
        }
    }
}
